type runtime.m

105 uses

	runtime (current package)
		cgocall.go#L243: func callbackUpdateSystemStack(mp *m, sp uintptr, signal bool) {
		coro.go#L32: 	mp        *m
		debug.go#L161: 	for mp := (*m)(atomic.Loadp(unsafe.Pointer(&allm))); mp != nil; mp = mp.alllink {
		debug.go#L171: 	for mp := (*m)(atomic.Loadp(unsafe.Pointer(&allm))); mp != nil; mp = mp.alllink {
		lock_futex.go#L136: func semacreate(mp *m) {}
		lock_futex.go#L158: func semawakeup(mp *m) {
		lock_spinbit.go#L418: 	var committed *m // If we choose an M within the stack, we've made a promise to wake it
		malloc.go#L2222: func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
		malloc_generated.go#L20: 	var mp *m
		malloc_generated.go#L173: 	var mp *m
		malloc_generated.go#L326: 	var mp *m
		malloc_generated.go#L479: 	var mp *m
		malloc_generated.go#L632: 	var mp *m
		malloc_generated.go#L785: 	var mp *m
		malloc_generated.go#L938: 	var mp *m
		malloc_generated.go#L1091: 	var mp *m
		malloc_generated.go#L1198: 	var mp *m
		malloc_generated.go#L1297: 	var mp *m
		malloc_generated.go#L1396: 	var mp *m
		malloc_generated.go#L1495: 	var mp *m
		malloc_generated.go#L1594: 	var mp *m
		malloc_generated.go#L1693: 	var mp *m
		malloc_generated.go#L1792: 	var mp *m
		malloc_generated.go#L1938: 	var mp *m
		malloc_generated.go#L2115: 	var mp *m
		malloc_stubs.go#L72: 	var mp *m
		malloc_stubs.go#L189: func inlinedMalloc(mp *m, size uintptr, typ *_type, needzero bool) unsafe.Pointer {
		malloc_stubs.go#L193: func doubleCheckSmallScanNoHeader(size uintptr, typ *_type, mp *m) {
		malloc_stubs.go#L210: func smallStub(mp *m, size uintptr, typ *_type, needzero bool) unsafe.Pointer {
		malloc_stubs.go#L334: func doubleCheckSmallNoScan(typ *_type, mp *m) {
		malloc_stubs.go#L346: func doubleCheckTiny(size uintptr, typ *_type, mp *m) {
		malloc_stubs.go#L360: func tinyStub(mp *m, size uintptr, typ *_type, needzero bool) unsafe.Pointer {
		mcache.go#L139: func getMCache(mp *m) *mcache {
		mheap.go#L2472: func gcParkStrongFromWeak() *m {
		mprof.go#L433: func mProf_Malloc(mp *m, p unsafe.Pointer, size uintptr) {
		mprof.go#L1215: 	first := (*m)(atomic.Loadp(unsafe.Pointer(&allm)))
		os_linux.go#L170: func newosproc(mp *m) {
		os_linux.go#L387: func mpreinit(mp *m) {
		os_linux.go#L419: func mdestroy(mp *m) {
		os_linux.go#L580: func signalM(mp *m, sig int) {
		os_linux.go#L591: func validSIGPROF(mp *m, c *sigctxt) bool {
		preempt.go#L120: 	var asyncM *m
		preempt.go#L289: func canPreemptM(mp *m) bool {
		preempt_nonwindows.go#L10: func osPreemptExtEnter(mp *m) {}
		preempt_nonwindows.go#L13: func osPreemptExtExit(mp *m) {}
		proc.go#L120: 	m0           m
		proc.go#L867: 	sched.midle.init(unsafe.Offsetof(m{}.idleNode))
		proc.go#L1011: func mcommoninit(mp *m, id int64) {
		proc.go#L1056: func mProfStackInit(mp *m) {
		proc.go#L1086: func (mp *m) becomeSpinning() {
		proc.go#L1099: func (mp *m) snapshotAllp() []*p {
		proc.go#L1110: func (mp *m) clearAllpSnapshot() {
		proc.go#L1114: func (mp *m) hasCgoOnStack() bool {
		proc.go#L2287: func allocm(pp *p, fn func(), id int64) *m {
		proc.go#L2304: 		var newList *m
		proc.go#L2761: func lockextra(nilokay bool) *m {
		proc.go#L2783: 			return (*m)(unsafe.Pointer(old))
		proc.go#L2791: func unlockextra(mp *m, delta int32) {
		proc.go#L2803: func getExtraM() (mp *m, last bool) {
		proc.go#L2814: func putExtraM(mp *m) {
		proc.go#L2822: func addExtraM(mp *m) {
		proc.go#L2924: func newm1(mp *m) {
		proc.go#L5163: func addGSyscallNoP(mp *m) {
		proc.go#L5183: func decGSyscallNoP(mp *m) {
		proc.go#L5799: func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
		proc.go#L5903: 		var mp *m
		proc.go#L6211: 		var mp *m
		proc.go#L6782: 	mp     *m
		proc.go#L7251: func mput(mp *m) {
		proc.go#L7264: func mget() *m {
		proc.go#L7267: 	mp := (*m)(sched.midle.pop())
		proc.go#L7281: func mgetSpecific(mp *m) *m {
		rand.go#L191: func mrandinit(mp *m) {
		runtime1.go#L612: func acquirem() *m {
		runtime1.go#L619: func releasem(mp *m) {
		runtime2.go#L289: func (mp muintptr) ptr() *m { return (*m)(unsafe.Pointer(mp)) }
		runtime2.go#L292: func (mp *muintptr) set(m *m) { *mp = muintptr(unsafe.Pointer(m)) }
		runtime2.go#L299: func setMNoWB(mp **m, new *m) {
		runtime2.go#L485: 	m         *m      // current m
		runtime2.go#L616: type m struct {
		runtime2.go#L671: 	alllink         *m // on allm
		runtime2.go#L692: 	freelink    *m // on sched.freem
		runtime2.go#L734: 	m
		runtime2.go#L740: 	_ [(1 - goarch.IsWasm) * (2048 - mallocHeaderSize - mRedZoneSize - unsafe.Sizeof(m{}))]byte
		runtime2.go#L752: 	m *atomic.Pointer[m]
		runtime2.go#L755: func newMWeakPointer(mp *m) mWeakPointer {
		runtime2.go#L756: 	w := mWeakPointer{m: new(atomic.Pointer[m])}
		runtime2.go#L761: func (w mWeakPointer) get() *m {
		runtime2.go#L990: 	freem *m
		runtime2.go#L1403: 	allm *m
		signal_unix.go#L369: func preemptM(mp *m) {
		signal_unix.go#L561: func adjustSignalStack(sig uint32, mp *m, gsigStack *gsignalStack) bool {
		signal_unix.go#L601: func adjustSignalStack2(sig uint32, sp uintptr, mp *m, ssDisable bool) {
		signal_unix.go#L845: func fatalsignal(sig uint32, c *sigctxt, gp *g, mp *m) *g {
		signal_unix.go#L1120: func sigNotOnStack(sig uint32, sp uintptr, mp *m) {
		tls_stub.go#L10: func osSetupTLS(mp *m) {}
		tracecpu.go#L213: func traceCPUSample(gp *g, mp *m, pp *p, stk []uintptr) {
		traceruntime.go#L30: 	link          *m                                   // Snapshot of alllink or freelink.
		traceruntime.go#L172: 	mp  *m
		traceruntime.go#L685: func traceThreadDestroy(mp *m) {
		tracestack.go#L36: 	var mp *m
		vgetrandom_linux.go#L81: func vgetrandomDestroy(mp *m) {